/*!-----------------------------------------------------------------------------
 * Copyright (c) Microsoft Corporation. All rights reserved.
 * Version: 0.46.0(21007360cad28648bdf46282a2592cb47c3a7a6f)
 * Released under the MIT license
 * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
 *-----------------------------------------------------------------------------*/
define('vs/basic-languages/typescript/typescript', ['require', 'require'], require => {
  'use strict'
  var moduleExports = (() => {
    var l = Object.create
    var s = Object.defineProperty
    var m = Object.getOwnPropertyDescriptor
    var x = Object.getOwnPropertyNames
    var b = Object.getPrototypeOf,
      u = Object.prototype.hasOwnProperty
    var f = (e =>
      typeof require < 'u'
        ? require
        : typeof Proxy < 'u'
          ? new Proxy(e, { get: (t, n) => (typeof require < 'u' ? require : t)[n] })
          : e)(function (e) {
      if (typeof require < 'u') return require.apply(this, arguments)
      throw Error('Dynamic require of "' + e + '" is not supported')
    })
    var k = (e, t) => () => (t || e((t = { exports: {} }).exports, t), t.exports),
      y = (e, t) => {
        for (var n in t) s(e, n, { get: t[n], enumerable: !0 })
      },
      i = (e, t, n, c) => {
        if ((t && typeof t == 'object') || typeof t == 'function')
          for (let r of x(t))
            !u.call(e, r) && r !== n && s(e, r, { get: () => t[r], enumerable: !(c = m(t, r)) || c.enumerable })
        return e
      },
      a = (e, t, n) => (i(e, t, 'default'), n && i(n, t, 'default')),
      p = (e, t, n) => (
        (n = e != null ? l(b(e)) : {}),
        i(t || !e || !e.__esModule ? s(n, 'default', { value: e, enumerable: !0 }) : n, e)
      ),
      w = e => i(s({}, '__esModule', { value: !0 }), e)
    var d = k((T, g) => {
      var A = p(f('vs/editor/editor.api'))
      g.exports = A
    })
    var h = {}
    y(h, { conf: () => v, language: () => $ })
    var o = {}
    a(o, p(d()))
    var v = {
        wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
        comments: { lineComment: '//', blockComment: ['/*', '*/'] },
        brackets: [
          ['{', '}'],
          ['[', ']'],
          ['(', ')'],
        ],
        onEnterRules: [
          {
            beforeText: /^\s*\/\*\*(?!\/)([^\*]|\*(?!\/))*$/,
            afterText: /^\s*\*\/$/,
            action: { indentAction: o.languages.IndentAction.IndentOutdent, appendText: ' * ' },
          },
          {
            beforeText: /^\s*\/\*\*(?!\/)([^\*]|\*(?!\/))*$/,
            action: { indentAction: o.languages.IndentAction.None, appendText: ' * ' },
          },
          {
            beforeText: /^(\t|(\ \ ))*\ \*(\ ([^\*]|\*(?!\/))*)?$/,
            action: { indentAction: o.languages.IndentAction.None, appendText: '* ' },
          },
          {
            beforeText: /^(\t|(\ \ ))*\ \*\/\s*$/,
            action: { indentAction: o.languages.IndentAction.None, removeText: 1 },
          },
        ],
        autoClosingPairs: [
          { open: '{', close: '}' },
          { open: '[', close: ']' },
          { open: '(', close: ')' },
          { open: '"', close: '"', notIn: ['string'] },
          { open: "'", close: "'", notIn: ['string', 'comment'] },
          { open: '`', close: '`', notIn: ['string', 'comment'] },
          { open: '/**', close: ' */', notIn: ['string'] },
        ],
        folding: {
          markers: { start: new RegExp('^\\s*//\\s*#?region\\b'), end: new RegExp('^\\s*//\\s*#?endregion\\b') },
        },
      },
      $ = {
        defaultToken: 'invalid',
        tokenPostfix: '.ts',
        keywords: [
          'abstract',
          'any',
          'as',
          'asserts',
          'bigint',
          'boolean',
          'break',
          'case',
          'catch',
          'class',
          'continue',
          'const',
          'constructor',
          'debugger',
          'declare',
          'default',
          'delete',
          'do',
          'else',
          'enum',
          'export',
          'extends',
          'false',
          'finally',
          'for',
          'from',
          'function',
          'get',
          'if',
          'implements',
          'import',
          'in',
          'infer',
          'instanceof',
          'interface',
          'is',
          'keyof',
          'let',
          'module',
          'namespace',
          'never',
          'new',
          'null',
          'number',
          'object',
          'out',
          'package',
          'private',
          'protected',
          'public',
          'override',
          'readonly',
          'require',
          'global',
          'return',
          'satisfies',
          'set',
          'static',
          'string',
          'super',
          'switch',
          'symbol',
          'this',
          'throw',
          'true',
          'try',
          'type',
          'typeof',
          'undefined',
          'unique',
          'unknown',
          'var',
          'void',
          'while',
          'with',
          'yield',
          'async',
          'await',
          'of',
        ],
        operators: [
          '<=',
          '>=',
          '==',
          '!=',
          '===',
          '!==',
          '=>',
          '+',
          '-',
          '**',
          '*',
          '/',
          '%',
          '++',
          '--',
          '<<',
          '</',
          '>>',
          '>>>',
          '&',
          '|',
          '^',
          '!',
          '~',
          '&&',
          '||',
          '??',
          '?',
          ':',
          '=',
          '+=',
          '-=',
          '*=',
          '**=',
          '/=',
          '%=',
          '<<=',
          '>>=',
          '>>>=',
          '&=',
          '|=',
          '^=',
          '@',
        ],
        symbols: /[=><!~?:&|+\-*\/\^%]+/,
        escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
        digits: /\d+(_+\d+)*/,
        octaldigits: /[0-7]+(_+[0-7]+)*/,
        binarydigits: /[0-1]+(_+[0-1]+)*/,
        hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
        regexpctl: /[(){}\[\]\$\^|\-*+?\.]/,
        regexpesc: /\\(?:[bBdDfnrstvwWn0\\\/]|@regexpctl|c[A-Z]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4})/,
        tokenizer: {
          root: [[/[{}]/, 'delimiter.bracket'], { include: 'common' }],
          common: [
            [/#?[a-z_$][\w$]*/, { cases: { '@keywords': 'keyword', '@default': 'identifier' } }],
            [/[A-Z][\w\$]*/, 'type.identifier'],
            { include: '@whitespace' },
            [
              /\/(?=([^\\\/]|\\.)+\/([dgimsuy]*)(\s*)(\.|;|,|\)|\]|\}|$))/,
              { token: 'regexp', bracket: '@open', next: '@regexp' },
            ],
            [/[()\[\]]/, '@brackets'],
            [/[<>](?!@symbols)/, '@brackets'],
            [/!(?=([^=]|$))/, 'delimiter'],
            [/@symbols/, { cases: { '@operators': 'delimiter', '@default': '' } }],
            [/(@digits)[eE]([\-+]?(@digits))?/, 'number.float'],
            [/(@digits)\.(@digits)([eE][\-+]?(@digits))?/, 'number.float'],
            [/0[xX](@hexdigits)n?/, 'number.hex'],
            [/0[oO]?(@octaldigits)n?/, 'number.octal'],
            [/0[bB](@binarydigits)n?/, 'number.binary'],
            [/(@digits)n?/, 'number'],
            [/[;,.]/, 'delimiter'],
            [/"([^"\\]|\\.)*$/, 'string.invalid'],
            [/'([^'\\]|\\.)*$/, 'string.invalid'],
            [/"/, 'string', '@string_double'],
            [/'/, 'string', '@string_single'],
            [/`/, 'string', '@string_backtick'],
          ],
          whitespace: [
            [/[ \t\r\n]+/, ''],
            [/\/\*\*(?!\/)/, 'comment.doc', '@jsdoc'],
            [/\/\*/, 'comment', '@comment'],
            [/\/\/.*$/, 'comment'],
          ],
          comment: [
            [/[^\/*]+/, 'comment'],
            [/\*\//, 'comment', '@pop'],
            [/[\/*]/, 'comment'],
          ],
          jsdoc: [
            [/[^\/*]+/, 'comment.doc'],
            [/\*\//, 'comment.doc', '@pop'],
            [/[\/*]/, 'comment.doc'],
          ],
          regexp: [
            [/(\{)(\d+(?:,\d*)?)(\})/, ['regexp.escape.control', 'regexp.escape.control', 'regexp.escape.control']],
            [
              /(\[)(\^?)(?=(?:[^\]\\\/]|\\.)+)/,
              ['regexp.escape.control', { token: 'regexp.escape.control', next: '@regexrange' }],
            ],
            [/(\()(\?:|\?=|\?!)/, ['regexp.escape.control', 'regexp.escape.control']],
            [/[()]/, 'regexp.escape.control'],
            [/@regexpctl/, 'regexp.escape.control'],
            [/[^\\\/]/, 'regexp'],
            [/@regexpesc/, 'regexp.escape'],
            [/\\\./, 'regexp.invalid'],
            [/(\/)([dgimsuy]*)/, [{ token: 'regexp', bracket: '@close', next: '@pop' }, 'keyword.other']],
          ],
          regexrange: [
            [/-/, 'regexp.escape.control'],
            [/\^/, 'regexp.invalid'],
            [/@regexpesc/, 'regexp.escape'],
            [/[^\]]/, 'regexp'],
            [/\]/, { token: 'regexp.escape.control', next: '@pop', bracket: '@close' }],
          ],
          string_double: [
            [/[^\\"]+/, 'string'],
            [/@escapes/, 'string.escape'],
            [/\\./, 'string.escape.invalid'],
            [/"/, 'string', '@pop'],
          ],
          string_single: [
            [/[^\\']+/, 'string'],
            [/@escapes/, 'string.escape'],
            [/\\./, 'string.escape.invalid'],
            [/'/, 'string', '@pop'],
          ],
          string_backtick: [
            [/\$\{/, { token: 'delimiter.bracket', next: '@bracketCounting' }],
            [/[^\\`$]+/, 'string'],
            [/@escapes/, 'string.escape'],
            [/\\./, 'string.escape.invalid'],
            [/`/, 'string', '@pop'],
          ],
          bracketCounting: [
            [/\{/, 'delimiter.bracket', '@bracketCounting'],
            [/\}/, 'delimiter.bracket', '@pop'],
            { include: 'common' },
          ],
        },
      }
    return w(h)
  })()
  return moduleExports
})
